home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / whisper / source / keyfunc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-19  |  12.2 KB  |  558 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <ctype.h>
  5. #include    <mos.h>
  6. #include    "defs.h"
  7. #include    "event.h"
  8. #include    "graphic.h"
  9. #include    "msg.h"
  10. #include    "buff.h"
  11. #include    "coldef.h"
  12. #include    "wind.h"
  13.  
  14. #define    MAX_KEY_TBL    100
  15.  
  16. char    *strdup(char *str);
  17. void    DEL_line(void);
  18. void    INS_line(void);
  19. void    KEY_undo(void);
  20. void    KEY_bs(void);
  21. void    KEY_cr(void);
  22. void    KEY_del(void);
  23. void    KEY_del_left(void);
  24. void    KEY_del_right(void);
  25. void    KEY_tab(void);
  26. void    KEY_ins_sw(void);
  27. void    KEY_left(void);
  28. void    KEY_right(void);
  29. void    KEY_up(void);
  30. void    KEY_down(void);
  31. void    KEY_line_btm(void);
  32. void    KEY_line_top(void);
  33. void    KEY_page_up(void);
  34. void    KEY_page_down(void);
  35. void    KEY_for_scrool(void);
  36. void    KEY_bak_scrool(void);
  37. void    KEY_mike_open(void);
  38. void    KEY_john_open(void);
  39. void    KEY_kent_open(void);
  40. void    KEY_jack_open(void);
  41. void    KEY_term_mike(void);
  42. void    KEY_term_john(void);
  43. void    KEY_term_kent(void);
  44. void    KEY_act_cheng(void);
  45. void    KEY_memo(void);
  46. void    TANGO_set(void);
  47. void    LIN_onoff(void);
  48. void    KEY_scl_dsp(void);
  49. void    KEY_word_left(void);
  50. void    KEY_word_right(void);
  51. void    KEY_scr_up(void);
  52. void    KEY_scr_down(void);
  53. void    KEY_null(void);
  54. void    WIN_scrn_event(EVENT *ep,int x,int y,int sw);
  55. void    KEY_cut_and_copy(void);
  56. void    KEY_cut(void);
  57. void    KEY_copy(void);
  58.  
  59. void    RSB_putc(int ch);
  60. void    TERM_pause_abort(void);
  61. int    kan_pos(char *p,int n);
  62. int    iskan(char *str);
  63. int    kbhit();
  64. int    getkey(unsigned *ec);
  65. void    WIN_col_buf(int no,int pos,int end);
  66.  
  67. extern int    TERM;
  68. extern int    act_wind;
  69. extern int    lin_new_flg;
  70. extern WIND    win[MAX_WIND];
  71.  
  72. static struct {
  73.     char    *func;
  74.     void    (*proc)();
  75. } key_func_tbl[]={
  76.     { "DEL_LINE",    DEL_line },
  77.     { "INS_LINE",    INS_line },
  78.     { "UNDO",    KEY_undo },
  79.     { "BS",        KEY_bs },
  80.     { "CR",        KEY_cr },
  81.     { "DEL",    KEY_del },
  82.     { "LEFT_DEL",    KEY_del_left },
  83.     { "RIGHT_DEL",    KEY_del_right },
  84.     { "TAB",    KEY_tab },
  85.     { "INS_SW",    KEY_ins_sw },
  86.     { "LEFT_CUR",    KEY_left },
  87.     { "RIGHT_CUR",    KEY_right },
  88.     { "LEFT_WORD",    KEY_word_left },
  89.     { "RIGHT_WORD",    KEY_word_right },
  90.     { "LINE_BTM",    KEY_line_btm },
  91.     { "LINE_TOP",    KEY_line_top },
  92.     { "UP_CUR",    KEY_up },
  93.     { "DOWN_CUR",    KEY_down },
  94.     { "UP_LINE",    KEY_scr_up },
  95.     { "DOWN_LINE",    KEY_scr_down },
  96.     { "UP_SCR",    KEY_page_up },
  97.     { "DOWN_SCR",    KEY_page_down },
  98.     { "FOR_SCR",    KEY_for_scrool },
  99.     { "BACK_SCR",    KEY_bak_scrool },
  100.     { "MIKE",    KEY_mike_open },
  101.     { "JOHN",    KEY_john_open },
  102.     { "KENT",    KEY_kent_open },
  103.     { "JACK",    KEY_jack_open },
  104.     { "MIKE_TERM",    KEY_term_mike },
  105.     { "JOHN_TERM",    KEY_term_john },
  106.     { "KENT_TERM",    KEY_term_kent },
  107.     { "ACT_CHENG",    KEY_act_cheng },
  108.     { "MEMO",    KEY_memo },
  109.     { "TANGO",    TANGO_set },
  110.     { "LINE_SW",    LIN_onoff },
  111.     { "SCL_SW",    KEY_scl_dsp },
  112.     { "CUT_COPY",    KEY_cut_and_copy },
  113.     { "CUT_KEY",    KEY_cut },
  114.     { "COPY_KEY",    KEY_copy },
  115.     { "NULL",    KEY_null },
  116.     { NULL,        KEY_null }
  117.     };
  118.  
  119. static struct {
  120.     int     code;
  121.     void    (*proc)();
  122.     char    *msg;
  123. } edit_key_tbl[MAX_KEY_TBL],term_key_tbl[MAX_KEY_TBL];
  124.  
  125. static int    edit_key_max=0;
  126. static int    term_key_max=0;
  127.  
  128. void    KEY_cut(void){}
  129. void    KEY_copy(void){}
  130. void    KEY_null(void){}        /* Nothing Func */
  131.  
  132. void    KEY_cut_and_copy(void)
  133. {
  134.     int     i,n,j,k,fg=0,rc=FALSE;
  135.     int     ch;
  136.     unsigned ec;
  137.     int     old_x,old_y;
  138.     int     old_ptr,old_pos;
  139.     int     x1=0,y1=0,x2=0,y2=0;
  140.     WIND    *wp;
  141.     CHI_PTR *cp;
  142.     LIN_PTR *lp;
  143.     LIN_PTR *tp;
  144.     static void (*move_proc[])()={
  145.     KEY_left,KEY_right,KEY_word_left,KEY_word_right,
  146.     KEY_line_btm,KEY_line_top,KEY_up,KEY_down,
  147.     KEY_scr_up,KEY_scr_down,KEY_page_up,KEY_page_down
  148.     };
  149.  
  150.     wp = &(win[act_wind]);
  151.     cp = &(wp->child[wp->now]);
  152.     if ( cp->now_ptr == ERR )
  153.     return;
  154.  
  155.     lp = get_lin(cp->now_ptr);
  156.     if ( cp->cur_x < strlen(lp->lin) )
  157.     cp->cur_x = kan_pos(lp->lin,cp->cur_x);
  158.  
  159.     old_ptr = cp->now_ptr;
  160.     old_pos = cp->lin_pos;
  161.     old_x = cp->cur_x;
  162.     old_y = cp->cur_y;
  163.  
  164.     MOS_disp(FALSE);
  165.     DSP_string("CUT©",
  166.     296,wp->wind_y + 4,COL_RED,wp->color);
  167.     WIN_dsp_buf(act_wind);
  168.  
  169.     for ( ; ; ) {
  170.     if ( old_ptr == cp->now_ptr ) {
  171.         old_pos = cp->lin_pos;
  172.         if ( fg == 2 )
  173.         WIN_dsp_buf(act_wind);
  174.         else if ( fg == 1 ) 
  175.             DSP_xline(x1,y1,x2,y2,7,4);
  176.         fg = 1;
  177.  
  178.         if ( old_x < cp->cur_x ) {
  179.         x1 = old_x * 8;
  180.         x2 = cp->cur_x * 8 - 1;
  181.         } else {
  182.         x1 = cp->cur_x * 8;
  183.         x2 = old_x * 8 + 7;
  184.         }
  185.  
  186.         y1 = wp->wind_y + 16 + cp->cur_y * 16;        
  187.         y2 = y1 + 15;
  188.         DSP_xline(x1,y1,x2,y2,7,4);
  189.  
  190.     } else {
  191.         fg = 2;
  192.         if ( old_pos <= cp->lin_pos )
  193.         WIN_col_buf(act_wind,old_pos,cp->lin_pos);
  194.         else
  195.         WIN_col_buf(act_wind,cp->lin_pos,old_pos);
  196.     }
  197.  
  198.     while ( kbhit() == 0 );
  199.     ch = getkey(&ec);
  200.     ec &= 0xFF14;
  201.     
  202.     for ( i = 0 ; i < edit_key_max ; i++ ) {
  203.         if ( edit_key_tbl[i].code == ec ) {
  204.         if ( edit_key_tbl[i].proc == KEY_cut ) {
  205.             rc = TRUE;
  206.             goto CUT_TRY;
  207.         } else if ( edit_key_tbl[i].proc == KEY_copy )
  208.             goto CUT_TRY;
  209.         for ( n = 0 ; n < 12 ; n++ ) {
  210.             if ( edit_key_tbl[i].proc == move_proc[n] ) {
  211.             (*edit_key_tbl[i].proc)();
  212.             break;
  213.             }
  214.         }
  215.         break;
  216.         }
  217.     }
  218.  
  219.     if ( ch == 0x1B )
  220.         goto ENDOF;
  221.     }
  222.  
  223. CUT_TRY:
  224.     if ( fg == 1 ) {
  225.     if ( cp->cur_x > old_x ) {
  226.         i = old_x;
  227.         n = cp->cur_x - old_x;
  228.     } else {
  229.         i = cp->cur_x;
  230.         n = old_x - cp->cur_x + 1;
  231.     }
  232.     MEMO_word_cut(act_wind,cp->lin_pos,i,n);
  233.  
  234.     if ( rc != FALSE && 
  235.         (j = get_lin_pos(act_wind,cp->lin_pos)) != ERR ) {
  236.         lp = get_lin(j);
  237.         if ( strlen(lp->lin) > i ) {
  238.         j = kan_pos(lp->lin,i);
  239.         k = kan_pos(lp->lin,i + n);
  240.         strcpy(&(lp->lin[j]),&(lp->lin[k]));
  241.         cp->cur_x = j;
  242.         cp->wrt_flg = TRUE;
  243.         }
  244.     }
  245.  
  246.  
  247.     } else if ( fg == 2 ) {
  248.     if ( old_pos <= cp->lin_pos ) {
  249.         i = old_pos;
  250.         n = cp->lin_pos;
  251.     } else {
  252.         i = cp->lin_pos;
  253.         n = old_pos;
  254.     }
  255.     MEMO_line_cut(act_wind,i,n);
  256.  
  257.     if ( rc != FALSE && 
  258.         (j = get_lin_pos(act_wind,i)) != ERR ) {
  259.         cp->now_ptr = j;
  260.         cp->lin_pos = i;
  261.         while ( i++ <= n )
  262.         DEL_line();
  263.         old_ptr = cp->now_ptr;
  264.         old_pos = cp->lin_pos;
  265.     }
  266.     }
  267.  
  268. ENDOF:
  269.     cp->now_ptr = old_ptr;
  270.     cp->lin_pos = old_pos;
  271.     cp->cur_x = old_x;
  272.     cp->cur_y = old_y;
  273.     WIN_dsp_buf(act_wind);
  274.     DSP_string("        ",
  275.     296,wp->wind_y + 4,COL_RED,wp->color);
  276.     MOS_disp(TRUE);
  277. }
  278. int    EDIT_KEY_chk(int code)
  279. {
  280.     int     i;
  281.  
  282.     for ( i = 0 ; i < edit_key_max ; i++ ) {
  283.     if ( edit_key_tbl[i].code == code )
  284.         return i;
  285.     }
  286.     return ERR;
  287. }
  288. int    EDIT_KEY_exec(int code,int i)
  289. {
  290.     for ( ; i < edit_key_max ; i++ ) {
  291.     if ( edit_key_tbl[i].code == code ) {
  292.         if ( edit_key_tbl[i].msg != NULL )
  293.         MSG_wind(edit_key_tbl[i].msg);
  294.         else
  295.         (*edit_key_tbl[i].proc)();
  296.         return TRUE;
  297.     }
  298.     }
  299.     return FALSE;
  300. }
  301. int    TERM_KEY_exec(int code)
  302. {
  303.     int     i;
  304.  
  305.     for ( i = 0 ; i < term_key_max ; i++ ) {
  306.     if ( term_key_tbl[i].code == code ) {
  307.         if ( term_key_tbl[i].msg != NULL )
  308.         MSG_wind(term_key_tbl[i].msg);
  309.         else
  310.         (*term_key_tbl[i].proc)();
  311.         return TRUE;
  312.     }
  313.     }
  314.     return FALSE;
  315. }
  316. void    EDIT_KEY_set(int code,char *func)
  317. {
  318.     int     i;
  319.  
  320.     if ( *func == '_' ) {
  321.     if ( edit_key_max < MAX_KEY_TBL ) {
  322.         edit_key_tbl[edit_key_max].code = code;
  323.         edit_key_tbl[edit_key_max].msg = strdup(func);
  324.         edit_key_max++;
  325.     }
  326.     return;
  327.     }
  328.  
  329.     for ( i = 0 ; key_func_tbl[i].func != NULL ; i++ ) {
  330.     if ( strcmp(key_func_tbl[i].func,func) == 0 ) {
  331.         if ( edit_key_max < MAX_KEY_TBL ) {
  332.             edit_key_tbl[edit_key_max].code = code;
  333.             edit_key_tbl[edit_key_max].proc = key_func_tbl[i].proc;
  334.             edit_key_tbl[edit_key_max].msg = NULL;
  335.         edit_key_max++;
  336.         }
  337.         return;
  338.     }
  339.     }
  340. }
  341. void    TERM_KEY_set(int code,char *func)
  342. {
  343.     int     i;
  344.  
  345.     if ( *func == '_' ) {
  346.     if ( term_key_max < MAX_KEY_TBL ) {
  347.         term_key_tbl[term_key_max].code = code;
  348.         term_key_tbl[term_key_max].msg = strdup(func);
  349.         term_key_max++;
  350.     }
  351.     return;
  352.     }
  353.  
  354.     for ( i = 0 ; key_func_tbl[i].func != NULL ; i++ ) {
  355.     if ( strcmp(key_func_tbl[i].func,func) == 0 ) {
  356.         if ( term_key_max < MAX_KEY_TBL ) {
  357.             term_key_tbl[term_key_max].code = code;
  358.             term_key_tbl[term_key_max].proc = key_func_tbl[i].proc;
  359.             term_key_tbl[term_key_max].msg = NULL;
  360.         term_key_max++;
  361.         }
  362.         return;
  363.     }
  364.     }
  365. }
  366. int    KEY_func_exec(char *func)
  367. {
  368.     int     i;
  369.  
  370.     for ( i = 0 ; key_func_tbl[i].func != NULL ; i++ ) {
  371.     if ( strcmp(key_func_tbl[i].func,func) == 0 ) {
  372.         (*key_func_tbl[i].proc)();
  373.         return FALSE;
  374.     }
  375.     }
  376.     return ERR;
  377. }
  378.  
  379. static char    *mos_mac[10]={ NULL,NULL,NULL,NULL,NULL,
  380.                    NULL,NULL,NULL,NULL,NULL };
  381.  
  382. void    MAC_event(register EVENT *ep)
  383. {
  384.     switch(ep->now) {
  385.     case EVT_CLIP_MOS:
  386.     EVT_clip_on(ep);
  387.     if ( *mos_mac[ep->no] == '_' )
  388.         ep->now = EVT_REP_MOS;
  389.     case EVT_ON_MOS:
  390.     DSP_mos(1);
  391.     break;
  392.  
  393.     case EVT_SELECT_MOS:
  394.     EVT_clip_off(ep);
  395.     DSP_mos(0);
  396.     case EVT_REP_MOS:
  397.     MSG_wind(mos_mac[ep->no]);
  398.     break;
  399.  
  400.     case EVT_DOLACK_MOS:
  401.     ep->now = EVT_NON;
  402.     case EVT_MOVE_MOS:
  403.     EVT_clip_off(ep);
  404.     case EVT_OFF_MOS:
  405.     DSP_mos(0);
  406.     break;
  407.     }
  408. }
  409. int    MAC_init(char *argv[])
  410. {
  411.     int     i;
  412.     char    tmp[16];
  413.  
  414.     DSP_box(0,464,560,479,COL_LINE,COL_WHIS);
  415.     EVT_level_free(250);
  416.     for ( i = 0 ; *argv != NULL && i < 10 ; i++ ) {
  417.     if ( mos_mac[i] != NULL ) {
  418.         free(mos_mac[i]);
  419.         mos_mac[i] = NULL;
  420.     }
  421.     if ( *argv[0] != '\0' ) {
  422.         sprintf(tmp,"%-6.6s",*(argv++));
  423.         EVT_sw(i*56+2,466,tmp,COL_WHIS2,COL_WHIS,250,MAC_event,i);
  424.         mos_mac[i] = strdup(*(argv++));
  425.     } else
  426.         argv += 2;
  427.     }
  428.     return i;
  429. }
  430.  
  431. #define    MAX_HIS    8
  432. #define    MAX_LIN    160
  433.  
  434. static struct _LB {
  435.     int     len;
  436.     int     pos;
  437.     char    buf[MAX_LIN+4];
  438. } lin_buf[MAX_HIS];
  439.  
  440. int    lin_his=0;
  441.  
  442. int    LIN_buf_pos(void)
  443. {
  444.     int     ofs;
  445.     struct _LB *lp;
  446.  
  447.     lp = &(lin_buf[lin_his]);
  448.  
  449.     if      ( lp->pos >= 110 ) ofs = 90;
  450.     else if ( lp->pos >= 70  ) ofs = 50;
  451.     else                ofs = 0;
  452.     ofs = kan_pos(lp->buf,ofs);
  453.  
  454.     return (lp->pos - ofs);
  455. }
  456. void    LIN_buf_dsp(void)
  457. {
  458.     int     ofs,n,y;
  459.     struct _LB *lp;
  460.     char    tmp[84];
  461.  
  462.     lp = &(lin_buf[lin_his]);
  463.  
  464.     if      ( lp->pos >= 110 ) ofs = 90;
  465.     else if ( lp->pos >= 70  ) ofs = 50;
  466.     else                ofs = 0;
  467.     ofs = kan_pos(lp->buf,ofs);
  468.     
  469.     lp->buf[lp->len] = '\0';
  470.     if ( (lp->len - ofs) >= 80 ) {
  471.     n = kan_pos(lp->buf,ofs + 80) - ofs;
  472.     strncpy(tmp,&(lp->buf[ofs]),n);
  473.     tmp[n] = '\0';
  474.     } else
  475.         strcpy(tmp,&(lp->buf[ofs]));
  476.  
  477.     y = win[TERM].wind_y + win[TERM].size_y - 16;
  478.     n = (lp->pos - ofs) * 8;
  479.  
  480.     cputstr(y*512,tmp,col_cnv[COL_BAK],col_cnv[COL_LINE]);
  481.     DSP_xline(n,y+14,n+7,y+15,15,4);
  482. }
  483. void    LIN_buf_flush(void)
  484. {
  485.     int     i;
  486.     struct _LB *lp;
  487.  
  488.     lp = &(lin_buf[lin_his]);
  489.  
  490.     TERM_pause_abort();
  491.     for ( i = 0 ; i < lp->len ; i++ )
  492.     RSB_putc(lp->buf[i]);
  493.  
  494.     if ( ++lin_his >= MAX_HIS )
  495.     lin_his = 0;
  496.  
  497.     lp = &(lin_buf[lin_his]);
  498.     lp->len = lp->pos = 0;
  499. }
  500. void    LIN_input(int ch)
  501. {
  502.     int     i,n;
  503.     char    *p;
  504.     struct _LB *lp;
  505.  
  506.     lp = &(lin_buf[lin_his]);
  507.     lp->buf[lp->len] = '\0';
  508.  
  509.     if ( ch == '\x08' && lp->pos > 0 ) {
  510.     lp->pos = kan_pos(lp->buf,lp->pos-1);
  511.     p = &(lp->buf[lp->pos]);
  512.     n = (iskan(p) ? 2:1);
  513.     strcpy(p,p+n);
  514.     lp->len -= n;
  515.  
  516.     } else if ( ch == 0x1B && lp->len > 0 ) {
  517.     lp->pos = lp->len = 0;
  518.  
  519.     } else if ( ch == 0x7F ) {
  520.     if ( lp->pos < lp->len ) {
  521.         p = &(lp->buf[lp->pos]);
  522.         n = (iskan(p) ? 2:1);
  523.         strcpy(p,p+n);
  524.         lp->len -= n;
  525.     }
  526.  
  527.     } else if ( ch == 0x1C ) {
  528.     if ( lp->pos < lp->len )
  529.         lp->pos += (iskan(&(lp->buf[lp->pos])) ? 2:1);
  530.  
  531.     } else if ( ch == 0x1D ) {
  532.     if ( lp->pos > 0 )
  533.         lp->pos = kan_pos(lp->buf,lp->pos-1);
  534.  
  535.     } else if ( ch == 0x1E ) {
  536.     if ( --lin_his < 0 )
  537.         lin_his = (MAX_HIS - 1);
  538.  
  539.     } else if ( ch == 0x1F ) {
  540.     if ( ++lin_his >= MAX_HIS )
  541.         lin_his = 0;
  542.  
  543.     } else if ( ch < ' ' ) {
  544.     LIN_buf_flush();
  545.     RSB_putc(ch);
  546.  
  547.     } else if ( lp->len < MAX_LIN ) {
  548.     if ( lp->pos < lp->len ) {
  549.         p = &(lp->buf[lp->len]);
  550.         for ( i = lp->len - lp->pos ; i > 0 ; i--,p-- )
  551.         *p = *(p-1);
  552.     }
  553.     lp->buf[lp->pos++] = ch;
  554.     lp->len++;
  555.     }
  556.     lin_new_flg = TRUE;
  557. }
  558.